home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / src / EvalMod2.mi < prev    next >
Text File  |  1992-11-24  |  29KB  |  1,136 lines
  1. IMPLEMENTATION MODULE EvalMod2;
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15. IMPORT SYSTEM, System, IO, Tree;
  16. (* line 7 "" *)
  17.  
  18.  
  19. FROM SYSTEM    IMPORT ADR;
  20. FROM IO        IMPORT WriteS, WriteNl, WriteI, StdOutput;
  21. FROM StringMem    IMPORT WriteString;
  22. FROM Idents    IMPORT tIdent;
  23. FROM Texts    IMPORT WriteText;
  24. FROM Sets    IMPORT tSet, MakeSet, ReleaseSet, Include, Minimum, IsElement, WriteSet;
  25. FROM Relations    IMPORT IsRelated;
  26. FROM TreeMod2    IMPORT WriteLine;
  27. FROM EvalMod    IMPORT EvalImplHead;
  28.  
  29. FROM Tree    IMPORT
  30.    NoTree    , tTree        , Referenced    , NoCodeClass    ,
  31.    Computed    , Reverse    , Write        , Read        ,
  32.    Inherited    , Synthesized    , Input        , Output    ,
  33.    Stack    , Parameter    , Variable    ,
  34.    CopyDef    , CopyUse    , Thread    , Virtual    ,
  35.    Test        , Left        , Right        ,
  36.    NonBaseComp    , First        , Dummy        , Trace        ,
  37.    Demand    , Funct        , NoClass    , Options    ,
  38.    TreeRoot    , iModule    , iMain        , itTree    ,
  39.    ForallClasses, ForallAttributes, f        , WI    , WN    ,
  40.    IdentifyAttribute, GrammarClass, cOAG    , MaxVisit    ,
  41.    WriteInstance;
  42.  
  43. VAR
  44.    Count, Start, Stop, Visit, ChildVisit, i, j, k    : SHORTCARD;
  45.    Node, Attr, Class, AttrClass, Child, Child2, ChildsClass    : tTree;
  46.  
  47. PROCEDURE Representative (i: CARDINAL): CARDINAL;    (* Class    *)
  48.    VAR
  49.       s        : tSet;
  50.       r        : CARDINAL;
  51.       Stable    : BOOLEAN;
  52.       j, k    : CARDINAL;
  53.    BEGIN
  54.       WITH Class^.Class DO
  55.      MakeSet (s, InstCount);
  56.      Include (s, i);
  57.      REPEAT
  58.         Stable := TRUE;
  59.         FOR j := 1 TO InstCount DO
  60.            IF IsElement (j, s) THEN
  61.           IF CopyDef IN Instance^[j].Properties THEN
  62.              k := Instance^[j].CopyArg;
  63.              IF (Parameter IN Instance^[k].Attribute^.Attribute.Properties) AND
  64.             NOT IsElement (k, s) THEN
  65.             Include (s, k);
  66.             Stable := FALSE;
  67.              END;
  68.           END;
  69.           IF CopyUse IN Instance^[j].Properties THEN
  70.              FOR k := 1 TO InstCount DO
  71.             IF (CopyDef IN Instance^[k].Properties) AND
  72.                (Parameter IN Instance^[k].Attribute^.Attribute.Properties) AND
  73.                (Instance^[k].CopyArg = j) AND
  74.                NOT IsElement (k, s) THEN
  75.                Include (s, k);
  76.                Stable := FALSE;
  77.             END;
  78.              END;
  79.           END;
  80.            END;
  81.         END;
  82.      UNTIL Stable;
  83.      r := Minimum (s);
  84.      IF r <= AttrCount THEN
  85.         Stable := TRUE;
  86.         j := r + 1;
  87.         LOOP
  88.            IF j > AttrCount THEN EXIT; END;
  89.            IF IsElement (j, s) THEN Stable := FALSE; EXIT; END;
  90.            INC (j);
  91.         END;
  92.         IF NOT Stable THEN
  93.            j := 1;
  94.            LOOP
  95.           k := Instance^ [j].Order;
  96.           IF (k <= AttrCount) AND IsElement (k, s) THEN r := k; EXIT; END;
  97.           INC (j);
  98.            END;
  99.         END;
  100.      END;
  101.      ReleaseSet (s);
  102.      RETURN r;
  103.       END;
  104.    END Representative;
  105.  
  106. PROCEDURE GenAttribute (i: CARDINAL; repr: BOOLEAN);    (* Class = subtype, Node = current type, k    *)
  107.    BEGIN
  108.       IF repr THEN
  109.      WITH Class^.Class.Instance^[i] DO
  110.         IF (Parameter IN Attribute^.Attribute.Properties) AND
  111.            (({CopyDef, CopyUse} * Properties) # {}) THEN
  112.            i := Representative (i);
  113.         END;
  114.      END;
  115.       END;
  116.       WITH Class^.Class.Instance^[i] DO
  117.      IF Virtual IN Properties THEN RETURN; END;
  118.      IF Left IN Properties THEN                    (* left        *)
  119.         WITH Attribute^.Attribute DO
  120.            IF Parameter IN Properties THEN
  121.           IF IdentifyAttribute (Node, Name) = NoTree THEN
  122.              WI (Class^.Class.Name); WriteS (f, "yy"); WI (Name);        (* local    *)
  123.           ELSE
  124.              WriteS (f, "yy"); WI (Name);                    (* param    *)
  125.           END;
  126.            ELSIF Demand IN Properties THEN                (* demand    *)
  127.           IF Funct IN Properties THEN
  128.              AttrClass := GetClass (Class, Name);        (* function    *)
  129.              WriteS (f, "y"); WI (AttrClass^.Class.Name); WriteS (f, "y"); WI (Name); WriteS (f, " (yyt)"); 
  130.           ELSIF i # k THEN
  131.              WI (Class^.Class.Name); WriteS (f, "yy"); WI (Name);        (* local    *)
  132.           ELSE
  133.              WriteS (f, "yy"); WI (Name);                    (* param    *)
  134.           END;
  135.            ELSE                            (* tree        *)
  136.           WriteS (f, "yyt^."); WI (Class^.Class.Name); WriteS (f, "."); WI (Name);
  137.            END;
  138.         END;
  139.      ELSE                                (* right    *)
  140.         WITH Attribute^.Attribute DO
  141.            IF Parameter IN Properties THEN                (* param    *)
  142.           WI (Class^.Class.Name); WriteS (f, "y"); WI (Selector^.Child.Name); WriteS (f, "y"); WI (Name);
  143.            ELSIF Demand IN Properties THEN                (* demand    *)
  144.           IF Funct IN Properties THEN                (* function    *)
  145.              AttrClass := GetClass (Selector^.Child.Class, Name);
  146.              WriteS (f, "y"); WI (AttrClass^.Class.Name); WriteS (f, "y"); WI (Name);
  147.              WriteS (f, " (yyt^."); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, ")"); 
  148.           ELSE
  149.              WI (Class^.Class.Name); WriteS (f, "y"); WI (Selector^.Child.Name); WriteS (f, "y"); WI (Name);
  150.           END;
  151.            ELSE                            (* tree        *)
  152.           WriteS (f, "yyt^."); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name);
  153.           WriteS (f, "^."); WI (Selector^.Child.Type); WriteS (f, "."); WI (Name);
  154.            END;
  155.         END;
  156.      END;
  157.       END;
  158.    END GenAttribute;
  159.  
  160. PROCEDURE GetClass (Class: tTree; Attribute: tIdent): tTree;
  161.    BEGIN
  162.       WHILE Class^.Kind # NoClass DO
  163.      IF IdentifyAttribute (Class^.Class.Attributes, Attribute) # NoTree THEN RETURN Class; END;
  164.      Class := Class^.Class.BaseClass;
  165.       END;
  166.       RETURN NoTree;
  167.    END GetClass;
  168.  
  169. PROCEDURE CheckUsage (Usage: BITSET): BOOLEAN;    (* Class, Child, Start, Stop    *)
  170.    VAR i, i2: SHORTCARD;
  171.    BEGIN
  172.       FOR i := Start TO Stop DO
  173.      i2 := Class^.Class.Instance^ [i].Order;
  174.      WITH Class^.Class.Instance^ [i2] DO
  175.         IF ({Synthesized, Right, First} <= Properties) AND
  176.            (Child = Selector) AND
  177.            (Attribute^.Child.Partition <= Selector^.Child.Class^.Class.Visits) AND
  178.            (Attribute^.Child.Partition IN Usage) THEN
  179.            RETURN TRUE;
  180.         END;
  181.         IF ({Inherited, Right} <= Properties) AND (i2 = j) THEN
  182.            RETURN TRUE;
  183.         END;
  184.      END;
  185.       END;
  186.       RETURN FALSE;
  187.    END CheckUsage;
  188.  
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256.  
  257.  
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270.  
  271.  
  272.  
  273.  
  274.  
  275.  
  276.  
  277.  
  278.  
  279.  
  280.  
  281.  
  282.  
  283.  
  284.  
  285.  
  286.  
  287.  
  288. PROCEDURE yyAbort (yyFunction: ARRAY OF CHAR);
  289.  BEGIN
  290.   IO.WriteS (IO.StdError, 'Error: module EvalMod2, routine ');
  291.   IO.WriteS (IO.StdError, yyFunction);
  292.   IO.WriteS (IO.StdError, ' failed');
  293.   IO.WriteNl (IO.StdError);
  294.   Exit;
  295.  END yyAbort;
  296.  
  297. PROCEDURE yyIsEqual (yya, yyb: ARRAY OF SYSTEM.BYTE): BOOLEAN;
  298.  VAR yyi    : INTEGER;
  299.  BEGIN
  300.   FOR yyi := 0 TO INTEGER (HIGH (yya)) DO
  301.    IF yya [yyi] # yyb [yyi] THEN RETURN FALSE; END;
  302.   END;
  303.   RETURN TRUE;
  304.  END yyIsEqual;
  305.  
  306. PROCEDURE EvalImplMod (t: Tree.tTree);
  307.  VAR yyTempo: RECORD CASE : INTEGER OF
  308.  END; END;
  309.  BEGIN
  310.   IF t = Tree.NoTree THEN RETURN; END;
  311.   IF (t^.Kind = Tree.Ag) THEN
  312. (* line 184 "" *)
  313.      WITH t^.Ag DO
  314. (* line 184 "" *)
  315.       
  316.     EvalImplHead (t);
  317.       IF NOT IsElement (ORD ('9'), Options) THEN
  318.     WriteNl (f);
  319.     WriteS (f, "PROCEDURE Eval (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, ");"); WriteNl (f);
  320.     WriteS (f, " VAR"); WriteNl (f);
  321.     Node := Classes;
  322.     Class := Classes;
  323.     ForallAttributes (Class, GenTemposLocal);
  324.     WriteS (f, " BEGIN"); 
  325.     IF MaxVisit > 0 THEN
  326.        Class := Classes;
  327.        Visit := 1;
  328.        WriteS (f, " yyVisit1"); WI (Class^.Class.Name); WriteS (f, " (yyt"); 
  329.        ForallAttributes (Class, GenActualsLeft);
  330.        WriteS (f, ");"); 
  331.     END;
  332.     WriteS (f, " END Eval;"); WriteNl (f);
  333.       ELSE
  334.     WriteNl (f);
  335.     WriteS (f, "VAR xxStack: CARDINAL;"); WriteNl (f);
  336.     WriteNl (f);
  337.     WriteS (f, "PROCEDURE Eval (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, ");"); WriteNl (f);
  338.     WriteS (f, " VAR xxHigh: BOOLEAN;"); WriteNl (f);
  339.     Node := Classes;
  340.     Class := Classes;
  341.     ForallAttributes (Class, GenTemposLocal);
  342.     WriteS (f, "BEGIN "); WriteNl (f);
  343.     WriteS (f, " xxStack := MAX (INTEGER);"); WriteNl (f);
  344.     IF MaxVisit > 0 THEN
  345.        Class := Classes;
  346.        Visit := 1;
  347.        WriteS (f, " yyVisit1"); WI (Class^.Class.Name); WriteS (f, " (yyt"); 
  348.        ForallAttributes (Class, GenActualsLeft);
  349.        WriteS (f, ");"); 
  350.     END; WriteNl (f);
  351.     WriteS (f, " IO.WriteS (IO.StdOutput, 'Stacksize ');"); WriteNl (f);
  352.     WriteS (f, " IO.WriteI (IO.StdOutput, CARDINAL (SYSTEM.ADR (xxHigh)) - xxStack, 0);"); WriteNl (f);
  353.     WriteS (f, " IO.WriteNl (IO.StdOutput);"); WriteNl (f);
  354.     WriteS (f, "END Eval;"); WriteNl (f);
  355.       END;
  356.     WriteNl (f);
  357.     ForallClasses (Classes, GenDemandProc);
  358.     ForallClasses (Classes, EvalImplMod);
  359.     WriteS (f, "PROCEDURE Begin"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  360.     WriteS (f, " BEGIN"); WriteNl (f);
  361.     WriteLine (EvalCodes^.Codes.BeginLine);
  362.     WriteText (f, EvalCodes^.Codes.Begin);
  363.     Node := Modules;
  364.     WHILE Node^.Kind = Tree.Module DO
  365.        WriteLine (Node^.Module.EvalCodes^.Codes.BeginLine);
  366.        WriteText (f, Node^.Module.EvalCodes^.Codes.Begin);
  367.        Node := Node^.Module.Next;
  368.     END;
  369.     WriteS (f, " END Begin"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  370.     WriteNl (f);
  371.     WriteS (f, "PROCEDURE Close"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  372.     WriteS (f, " BEGIN"); WriteNl (f);
  373.     WriteLine (EvalCodes^.Codes.CloseLine);
  374.     WriteText (f, EvalCodes^.Codes.Close);
  375.     Node := Modules;
  376.     WHILE Node^.Kind = Tree.Module DO
  377.        WriteLine (Node^.Module.EvalCodes^.Codes.CloseLine);
  378.        WriteText (f, Node^.Module.EvalCodes^.Codes.Close);
  379.        Node := Node^.Module.Next;
  380.     END;
  381.     WriteS (f, " END Close"); WI (EvalName); WriteS (f, ";"); WriteNl (f);
  382.     WriteNl (f);
  383.     WriteS (f, "BEGIN"); WriteNl (f);
  384.       IF IsElement (ORD ('X'), Options) THEN
  385.     WriteS (f, " yyf := IO.StdOutput;"); WriteNl (f);
  386.       END;
  387.     WriteS (f, "END "); WI (EvalName); WriteS (f, "."); WriteNl (f);
  388. ;
  389.       RETURN;
  390.      END;
  391.  
  392.   END;
  393.   IF (t^.Kind = Tree.Class) THEN
  394. (* line 258 "" *)
  395.      WITH t^.Class DO
  396. (* line 258 "" *)
  397.       
  398.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  399.     IF Referenced IN Properties THEN
  400.        Generated := 0;
  401.        ForallClasses (Extensions, Generated0);
  402.        FOR Visit := 1 TO Visits DO
  403.           WriteS (f, "PROCEDURE yyVisit"); WN (Visit); WI (Name); WriteS (f, " (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree);
  404.           Node := t;
  405.           Class := t;
  406.           ForallAttributes (t, GenFormals);
  407.           WriteS (f, ");"); WriteNl (f);
  408.           WriteS (f, " VAR yyTempo: RECORD CASE : INTEGER OF"); WriteNl (f);
  409.           Node := t;
  410.           GenTempos (t);
  411.           ForallClasses (Extensions, GenTempos);
  412.           WriteS (f, " END; END;"); WriteNl (f);
  413.           WriteLine (TreeRoot^.Ag.EvalCodes^.Codes.LocalLine);
  414.           WriteText (f, TreeRoot^.Ag.EvalCodes^.Codes.Local);
  415.           Node := TreeRoot^.Ag.Modules;
  416.           WHILE Node^.Kind = Tree.Module DO
  417.          WriteLine (Node^.Module.EvalCodes^.Codes.LocalLine);
  418.          WriteText (f, Node^.Module.EvalCodes^.Codes.Local);
  419.          Node := Node^.Module.Next;
  420.           END;
  421.       IF IsElement (ORD ('9'), Options) THEN
  422.           WriteS (f, " VAR xxLow: BOOLEAN;"); WriteNl (f);
  423.           WriteS (f, " BEGIN"); WriteNl (f);
  424.           WriteS (f, "  xxStack := General.Min (xxStack, CARDINAL (SYSTEM.ADR (xxLow)));"); WriteNl (f);
  425.       ELSE
  426.           WriteS (f, " BEGIN"); WriteNl (f);
  427.       END;
  428.           WriteS (f, "  WITH yyTempo DO"); WriteNl (f);
  429.           WriteS (f, "   CASE yyt^.Kind OF"); WriteNl (f);
  430.           IF cOAG IN GrammarClass THEN        (* generate evaluator    *)
  431.          Node := t;
  432.          GenEvaluator (t);
  433.          ForallClasses (Extensions, GenEvaluator);
  434.           END;
  435.           WriteS (f, "   ELSE"); WriteNl (f);
  436.       IF IsElement (ORD ('Z'), Options) THEN
  437.           WriteS (f, "    yyVisitParent (yyt);"); WriteNl (f);
  438.       END;
  439.           WriteS (f, "   END;"); WriteNl (f);
  440.           WriteS (f, "  END;"); WriteNl (f);
  441.           WriteS (f, " END yyVisit"); WN (Visit); WI (Name); WriteS (f, ";"); WriteNl (f);
  442.           WriteNl (f);
  443.        END;
  444.     END;
  445. ;
  446.       RETURN;
  447.      END;
  448.  
  449.   END;
  450.  END EvalImplMod;
  451.  
  452. PROCEDURE WriteType (t: Tree.tTree);
  453.  VAR yyTempo: RECORD CASE : INTEGER OF
  454.  END; END;
  455.  BEGIN
  456.   IF t = Tree.NoTree THEN RETURN; END;
  457.   IF (t^.Kind = Tree.Class) THEN
  458. (* line 311 "" *)
  459.      WITH t^.Class DO
  460. (* line 311 "" *)
  461.       
  462.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  463.     IF Trace IN Properties THEN
  464.        WriteS (f, "| "); WI (iMain); WriteS (f, "."); WI (Name); WriteS (f, ": yyWriteS ('"); WI (Name); WriteS (f, "');"); WriteNl (f);
  465.     END;
  466. ;
  467.       RETURN;
  468.      END;
  469.  
  470.   END;
  471.  END WriteType;
  472.  
  473. PROCEDURE GenEvaluator (t: Tree.tTree);
  474.  VAR yyTempo: RECORD CASE : INTEGER OF
  475.  END; END;
  476.  BEGIN
  477.   IF t = Tree.NoTree THEN RETURN; END;
  478.  
  479.   CASE t^.Kind OF
  480.   | Tree.Class:
  481. (* line 321 "" *)
  482.      WITH t^.Class DO
  483. (* line 321 "" *)
  484.       
  485.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  486.     IF (Generated = InstCount) THEN RETURN; END;
  487.     WriteS (f, "| "); WI (iMain); WriteS (f, "."); WI (Name); WriteS (f, ":"); WriteNl (f);
  488.  
  489.     Start := Generated + 1;
  490.     LOOP
  491.        IF Generated = InstCount THEN EXIT; END;
  492.        INC (Generated);
  493.        WITH Instance^ [Instance^ [Generated].Order] DO
  494.           IF (Left IN Properties) AND (Attribute^.Child.Partition > Visit) THEN
  495.              DEC (Generated); EXIT;
  496.           END;
  497.        END;
  498.     END;
  499.     Stop := Generated;
  500.  
  501.     Class := t;
  502.  
  503.     FOR Start := Start TO Stop DO
  504.        i := Instance^ [Start].Order;
  505.        WITH Instance^ [i] DO
  506.           IF ({Inherited, Right, First} <= Properties) AND ({Dummy, Virtual, Demand} * Properties = {}) THEN
  507.          GenDemandEval (t);
  508.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  509.          WriteS (f, "yyWriteEval (yyt, '"); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, "');"); WriteNl (f);
  510.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; WriteNl (f);
  511.          IF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  512.             WriteS (f, "write"); WI (itTree); WriteS (f, " ("); GenAttribute (i, TRUE); WriteS (f, ")"); WriteNl (f);
  513.          ELSE
  514.             WriteS (f, "write"); WI (Attribute^.Child.Type); WriteS (f, " ("); GenAttribute (i, TRUE); WriteS (f, ") yyWriteNl;"); WriteNl (f);
  515.          END;
  516.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  517.          WriteS (f, "yyWriteEval (yyt, '"); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, "');"); WriteNl (f);
  518.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  519.       ELSE
  520.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  521.       END;
  522.           END;
  523.           IF ({Synthesized, Left, First} <= Properties) AND ({Dummy, Virtual, Demand} * Properties = {}) THEN
  524.          GenDemandEval (t);
  525.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  526.          WriteS (f, "yyWriteEval (yyt, '"); WI (Attribute^.Child.Name); WriteS (f, "');"); WriteNl (f);
  527.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; WriteNl (f);
  528.          IF Test IN Properties THEN
  529.             WriteS (f, "writeBOOLEAN (yyb) yyWriteNl;"); WriteNl (f);
  530.          ELSIF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  531.             WriteS (f, "write"); WI (itTree); WriteS (f, " ("); GenAttribute (i, TRUE); WriteS (f, ")"); WriteNl (f);
  532.          ELSE
  533.             WriteS (f, "write"); WI (Attribute^.Child.Type); WriteS (f, " ("); GenAttribute (i, TRUE); WriteS (f, ") yyWriteNl;"); WriteNl (f);
  534.          END;
  535.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  536.          WriteS (f, "yyWriteEval (yyt, '"); WI (Attribute^.Child.Name); WriteS (f, "');"); WriteNl (f);
  537.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  538.       ELSE
  539.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  540.       END;
  541.           END;
  542.           IF ({Synthesized, Right, First} <= Properties) AND
  543.          (Attribute^.Child.Partition <= Selector^.Child.Class^.Class.Visits) THEN
  544.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  545.          WriteS (f, "yyWriteVisit (yyt, '"); WI (Selector^.Child.Name); WriteS (f, " "); 
  546.          WN (Attribute^.Child.Partition); WriteS (f, "');"); WriteNl (f);
  547.       END;
  548.          ChildVisit := Attribute^.Child.Partition;
  549.          Child := Selector;
  550.          WriteS (f, "yyVisit"); WN (ChildVisit); WI (Child^.Child.Type);
  551.          WriteS (f, " (yyt^."); WI (Name); WriteS (f, "."); WI (Child^.Child.Name);
  552.          ForallAttributes (Child^.Child.Class, GenActualsRight);
  553.          WriteS (f, ");"); WriteNl (f);
  554.           END;
  555.        END;
  556.     END;
  557.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  558.     WriteS (f, "yyVisitParent (yyt);"); WriteNl (f);
  559.       END;
  560. ;
  561.       RETURN;
  562.      END;
  563.  
  564.   | Tree.Assign:
  565. (* line 398 "" *)
  566.      WITH t^.Assign DO
  567. (* line 398 "" *)
  568.       
  569.     WriteLine (Pos);
  570.     GenEvaluator (Results); WriteS (f, ":="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  571. ;
  572.       RETURN;
  573.      END;
  574.  
  575.   | Tree.Copy:
  576. (* line 402 "" *)
  577.      WITH t^.Copy DO
  578. (* line 402 "" *)
  579.       
  580.     j := Class^.Class.Instance^[i].CopyArg;
  581.     IF (Parameter IN Class^.Class.Instance^[i].Attribute^.Attribute.Properties) AND
  582.        (Parameter IN Class^.Class.Instance^[j].Attribute^.Attribute.Properties) THEN
  583.        IF (Left IN Class^.Class.Instance^[i].Properties) AND
  584.           (Left IN Class^.Class.Instance^[j].Properties) THEN
  585.  
  586.           WriteLine (Pos);
  587.           GenAttribute (i, FALSE); WriteS (f, " :="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  588.        END;
  589.     ELSE
  590.        WriteLine (Pos);
  591.        GenEvaluator (Results); WriteS (f, ":="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  592.     END;
  593. ;
  594.       RETURN;
  595.      END;
  596.  
  597.   | Tree.TargetCode:
  598. (* line 417 "" *)
  599.      WITH t^.TargetCode DO
  600. (* line 417 "" *)
  601.       
  602.     WriteLine (Pos);
  603.     GenEvaluator (Code); WriteNl (f);
  604. ;
  605.       RETURN;
  606.      END;
  607.  
  608.   | Tree.Check:
  609. (* line 421 "" *)
  610.      WITH t^.Check DO
  611. (* line 421 "" *)
  612.       
  613.     WriteLine (Pos);
  614.     IF Condition # NoTree THEN
  615.       IF IsElement (ORD ('X'), Options) THEN
  616.        WriteS (f, "yyb := "); GenEvaluator (Condition); WriteS (f, "; IF NOT yyb THEN "); 
  617.       ELSE
  618.        WriteS (f, "IF NOT ("); GenEvaluator (Condition); WriteS (f, ") THEN "); 
  619.       END;
  620.        GenEvaluator (Statement); WriteNl (f);
  621.        IF Actions^.Kind = Tree.Check THEN
  622.           WriteS (f, "ELSE "); GenEvaluator (Actions);
  623.        END;
  624.        WriteS (f, " END;"); WriteNl (f);
  625.     ELSE
  626.       IF IsElement (ORD ('X'), Options) THEN
  627.        WriteS (f, "yyb := FALSE; "); 
  628.       END;
  629.        GenEvaluator (Statement); WriteS (f, ";"); WriteNl (f);
  630.        GenEvaluator (Actions);
  631.     END;
  632. ;
  633.       RETURN;
  634.      END;
  635.  
  636.   | Tree.Designator:
  637. (* line 442 "" *)
  638.      WITH t^.Designator DO
  639. (* line 442 "" *)
  640.       
  641.     Child2 := IdentifyAttribute (Class, Selector);
  642.     IF Child2 # NoTree THEN
  643.        ChildsClass := Child2^.Child.Class;
  644.        Attr := IdentifyAttribute (ChildsClass, Attribute);
  645.        IF Attr # NoTree THEN
  646.           GenAttribute (Class^.Class.AttrCount + Child2^.Child.InstOffset + Attr^.Attribute.AttrIndex, TRUE);
  647.        ELSE
  648.           WI (Selector); WriteS (f, ":"); WI (Attribute);
  649.        END;
  650.     ELSE
  651.        WI (Selector); WriteS (f, ":"); WI (Attribute);
  652.     END;
  653.     GenEvaluator (Next);
  654. ;
  655.       RETURN;
  656.      END;
  657.  
  658.   | Tree.Ident:
  659. (* line 457 "" *)
  660.      WITH t^.Ident DO
  661. (* line 457 "" *)
  662.       
  663.     Attr := IdentifyAttribute (Class, Attribute);
  664.     IF Attr # NoTree THEN
  665.        GenAttribute (Attr^.Attribute.AttrIndex, TRUE);
  666.     ELSE
  667.        WI (Attribute);
  668.     END;
  669.     GenEvaluator (Next);
  670. ;
  671.       RETURN;
  672.      END;
  673.  
  674.   | Tree.Any:
  675. (* line 466 "" *)
  676.      WITH t^.Any DO
  677. (* line 466 "" *)
  678.       
  679.     WriteString (f, Code);
  680.     GenEvaluator (Next);
  681. ;
  682.       RETURN;
  683.      END;
  684.  
  685.   | Tree.Anys:
  686. (* line 470 "" *)
  687.      WITH t^.Anys DO
  688. (* line 470 "" *)
  689.       
  690.     GenEvaluator (Layouts);
  691.     GenEvaluator (Next);
  692. ;
  693.       RETURN;
  694.      END;
  695.  
  696.   | Tree.LayoutAny:
  697. (* line 474 "" *)
  698.      WITH t^.LayoutAny DO
  699. (* line 474 "" *)
  700.       
  701.     WriteString (f, Code);
  702.     GenEvaluator (Next);
  703. ;
  704.       RETURN;
  705.      END;
  706.  
  707.   ELSE END;
  708.  
  709.  END GenEvaluator;
  710.  
  711. PROCEDURE Generated0 (t: Tree.tTree);
  712.  VAR yyTempo: RECORD CASE : INTEGER OF
  713.  END; END;
  714.  BEGIN
  715.   IF t = Tree.NoTree THEN RETURN; END;
  716.   IF (t^.Kind = Tree.Class) THEN
  717. (* line 482 "" *)
  718.      WITH t^.Class DO
  719. (* line 482 "" *)
  720.       
  721.     Generated := 0;
  722. ;
  723.       RETURN;
  724.      END;
  725.  
  726.   END;
  727.  END Generated0;
  728.  
  729. PROCEDURE GenFormals (t: Tree.tTree);
  730.  VAR yyTempo: RECORD CASE : INTEGER OF
  731.  END; END;
  732.  BEGIN
  733.   IF t = Tree.NoTree THEN RETURN; END;
  734.   IF (t^.Kind = Tree.Attribute) THEN
  735. (* line 489 "" *)
  736.      WITH t^.Attribute DO
  737. (* line 489 "" *)
  738.       
  739.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  740.        WriteS (f, "; VAR "); GenAttribute (AttrIndex, FALSE); WriteS (f, ": "); WI (Type);
  741.     END;
  742. ;
  743.       RETURN;
  744.      END;
  745.  
  746.   END;
  747.  END GenFormals;
  748.  
  749. PROCEDURE GenActualsRight (t: Tree.tTree);
  750.  VAR yyTempo: RECORD CASE : INTEGER OF
  751.  END; END;
  752.  BEGIN
  753.   IF t = Tree.NoTree THEN RETURN; END;
  754.   IF (t^.Kind = Tree.Attribute) THEN
  755. (* line 498 "" *)
  756.      WITH t^.Attribute DO
  757. (* line 498 "" *)
  758.       
  759.     IF (Parameter IN Properties) AND (ChildVisit IN Usage) THEN
  760.        WriteS (f, ", "); GenAttribute (Class^.Class.AttrCount + Child^.Child.InstOffset + AttrIndex, TRUE);
  761.     END;
  762. ;
  763.       RETURN;
  764.      END;
  765.  
  766.   END;
  767.  END GenActualsRight;
  768.  
  769. PROCEDURE GenActualsLeft (t: Tree.tTree);
  770.  VAR yyTempo: RECORD CASE : INTEGER OF
  771.  END; END;
  772.  BEGIN
  773.   IF t = Tree.NoTree THEN RETURN; END;
  774.   IF (t^.Kind = Tree.Attribute) THEN
  775. (* line 507 "" *)
  776.      WITH t^.Attribute DO
  777. (* line 507 "" *)
  778.       
  779.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  780.        WriteS (f, ", "); GenAttribute (AttrIndex, FALSE);
  781.     END;
  782. ;
  783.       RETURN;
  784.      END;
  785.  
  786.   END;
  787.  END GenActualsLeft;
  788.  
  789. PROCEDURE GenTempos (t: Tree.tTree);
  790.  VAR yyTempo: RECORD CASE : INTEGER OF
  791.  END; END;
  792.  BEGIN
  793.   IF t = Tree.NoTree THEN RETURN; END;
  794.   IF (t^.Kind = Tree.Class) THEN
  795. (* line 516 "" *)
  796.      WITH t^.Class DO
  797. (* line 516 "" *)
  798.       
  799.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  800.     Start := Generated + 1;
  801.     LOOP
  802.        IF Generated = InstCount THEN EXIT; END;
  803.        INC (Generated);
  804.        WITH Instance^ [Instance^ [Generated].Order] DO
  805.           IF (Left IN Properties) AND (Attribute^.Child.Partition > Visit) THEN
  806.              DEC (Generated); EXIT;
  807.           END;
  808.        END;
  809.     END;
  810.     Stop := Generated;
  811.     Generated := Start - 1;
  812.  
  813.     Count := 0;
  814.     Class := t;
  815.     ForallAttributes (t, CountTempos);
  816.     IF Count > 0 THEN
  817.        WriteS (f, " | "); WI (iMain); WriteS (f, "."); WI (Name); WriteS (f, ":"); WriteNl (f);
  818.        Class := t;
  819.        ForallAttributes (t, GenTempos);
  820.     END;
  821. ;
  822.       RETURN;
  823.      END;
  824.  
  825.   END;
  826.   IF (t^.Kind = Tree.Child) THEN
  827. (* line 540 "" *)
  828.      WITH t^.Child DO
  829. (* line 540 "" *)
  830.       
  831.     Child := t;
  832.     ForallAttributes (Class, GenTemposChildren);
  833. ;
  834.       RETURN;
  835.      END;
  836.  
  837.   END;
  838.   IF (t^.Kind = Tree.Attribute) THEN
  839. (* line 544 "" *)
  840.      WITH t^.Attribute DO
  841. (* line 544 "" *)
  842.       
  843.     IF (Parameter IN Properties) AND (IdentifyAttribute (Node, Name) = NoTree) AND (Visit IN Usage) OR
  844.        (Demand IN Properties) AND NOT (Funct IN Properties) AND (AttrIndex # k) THEN
  845.        WriteS (f, "  "); GenAttribute (AttrIndex, FALSE); WriteS (f, ": "); WI (Type); WriteS (f, ";"); WriteNl (f);
  846.     END;
  847. ;
  848.       RETURN;
  849.      END;
  850.  
  851.   END;
  852.  END GenTempos;
  853.  
  854. PROCEDURE GenTemposChildren (t: Tree.tTree);
  855.  VAR yyTempo: RECORD CASE : INTEGER OF
  856.  END; END;
  857.  BEGIN
  858.   IF t = Tree.NoTree THEN RETURN; END;
  859.   IF (t^.Kind = Tree.Attribute) THEN
  860. (* line 554 "" *)
  861.      WITH t^.Attribute DO
  862. (* line 554 "" *)
  863.       
  864.     IF (Parameter IN Properties) OR
  865.        (Demand IN Properties) AND NOT (Funct IN Properties) THEN
  866.        j := Class^.Class.AttrCount + Child^.Child.InstOffset + AttrIndex;
  867.        IF (Demand IN Properties) OR
  868.           (({CopyDef, CopyUse} * Class^.Class.Instance^[j].Properties) = {}) OR
  869.           (j = Representative (j)) THEN
  870.           IF CheckUsage (Usage) THEN
  871.          WriteS (f, "  "); GenAttribute (j, FALSE); WriteS (f, ": "); WI (Type); WriteS (f, ";"); WriteNl (f);
  872.           END;
  873.        END;
  874.     END;
  875. ;
  876.       RETURN;
  877.      END;
  878.  
  879.   END;
  880.  END GenTemposChildren;
  881.  
  882. PROCEDURE CountTempos (t: Tree.tTree);
  883.  VAR yyTempo: RECORD CASE : INTEGER OF
  884.  END; END;
  885.  BEGIN
  886.   IF t = Tree.NoTree THEN RETURN; END;
  887.   IF (t^.Kind = Tree.Child) THEN
  888. (* line 571 "" *)
  889.      WITH t^.Child DO
  890. (* line 571 "" *)
  891.       
  892.     Child := t;
  893.     ForallAttributes (Class, CountTemposChildren);
  894. ;
  895.       RETURN;
  896.      END;
  897.  
  898.   END;
  899.   IF (t^.Kind = Tree.Attribute) THEN
  900. (* line 575 "" *)
  901.      WITH t^.Attribute DO
  902. (* line 575 "" *)
  903.       
  904.     IF (Parameter IN Properties) AND (IdentifyAttribute (Node, Name) = NoTree) AND (Visit IN Usage) OR
  905.        (Demand IN Properties) AND NOT (Funct IN Properties) AND (AttrIndex # k) THEN
  906.        INC (Count);
  907.     END;
  908. ;
  909.       RETURN;
  910.      END;
  911.  
  912.   END;
  913.  END CountTempos;
  914.  
  915. PROCEDURE CountTemposChildren (t: Tree.tTree);
  916.  VAR yyTempo: RECORD CASE : INTEGER OF
  917.  END; END;
  918.  BEGIN
  919.   IF t = Tree.NoTree THEN RETURN; END;
  920.   IF (t^.Kind = Tree.Attribute) THEN
  921. (* line 585 "" *)
  922.      WITH t^.Attribute DO
  923. (* line 585 "" *)
  924.       
  925.     IF (Parameter IN Properties) OR
  926.        (Demand IN Properties) AND NOT (Funct IN Properties) THEN
  927.        j := Class^.Class.AttrCount + Child^.Child.InstOffset + AttrIndex;
  928.        IF (Demand IN Properties) OR
  929.           (({CopyDef, CopyUse} * Class^.Class.Instance^[j].Properties) = {}) OR
  930.           (j = Representative (j)) THEN
  931.           IF CheckUsage (Usage) THEN INC (Count); END;
  932.        END;
  933.     END;
  934. ;
  935.       RETURN;
  936.      END;
  937.  
  938.   END;
  939.  END CountTemposChildren;
  940.  
  941. PROCEDURE GenTemposLocal (t: Tree.tTree);
  942.  VAR yyTempo: RECORD CASE : INTEGER OF
  943.  END; END;
  944.  BEGIN
  945.   IF t = Tree.NoTree THEN RETURN; END;
  946.   IF (t^.Kind = Tree.Attribute) THEN
  947. (* line 600 "" *)
  948.      WITH t^.Attribute DO
  949. (* line 600 "" *)
  950.       
  951.     IF Parameter IN Properties THEN
  952.        WriteS (f, "  "); GenAttribute (AttrIndex, FALSE); WriteS (f, ": "); WI (Type); WriteS (f, ";"); WriteNl (f);
  953.     END;
  954. ;
  955.       RETURN;
  956.      END;
  957.  
  958.   END;
  959.  END GenTemposLocal;
  960.  
  961. PROCEDURE GenDemandProc (t: Tree.tTree);
  962.  VAR yyTempo: RECORD CASE : INTEGER OF
  963.  END; END;
  964.  BEGIN
  965.   IF t = Tree.NoTree THEN RETURN; END;
  966.   IF (t^.Kind = Tree.Class) THEN
  967. (* line 609 "" *)
  968.      WITH t^.Class DO
  969. (* line 609 "" *)
  970.       
  971.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  972.     Node := t;
  973.     ForallAttributes (Attributes, GenDemandProc);
  974. ;
  975.       RETURN;
  976.      END;
  977.  
  978.   END;
  979.   IF (t^.Kind = Tree.Attribute) THEN
  980. (* line 614 "" *)
  981.      WITH t^.Attribute DO
  982. (* line 614 "" *)
  983.       
  984.     IF Demand IN Properties THEN
  985.        Class := Node;
  986.        k := AttrIndex;
  987.        IF Funct IN Properties THEN
  988.           WriteS (f, "PROCEDURE y"); WI (Class^.Class.Name); WriteS (f, "y"); WI (Name);
  989.           WriteS (f, " (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, "): "); WI (Type); WriteS (f, ";"); WriteNl (f);
  990.        ELSE
  991.           WriteS (f, "PROCEDURE y"); WI (Class^.Class.Name); WriteS (f, "y"); WI (Name);
  992.           WriteS (f, " (yyt: "); WI (iMain); WriteS (f, "."); WI (itTree); WriteS (f, "; VAR "); GenAttribute (AttrIndex, FALSE); WriteS (f, ": "); WI (Type); WriteS (f, ");"); WriteNl (f);
  993.        END;
  994.        WriteS (f, " VAR yyTempo: RECORD CASE : INTEGER OF"); WriteNl (f);
  995.        GenTempos (Class);
  996.        ForallClasses (Class^.Class.Extensions, GenTempos);
  997.        WriteS (f, " END; END;"); WriteNl (f);
  998.        WriteS (f, " BEGIN"); WriteNl (f);
  999.        WriteS (f, "  WITH yyTempo DO"); WriteNl (f);
  1000.        WriteS (f, "   CASE yyt^.Kind OF"); WriteNl (f);
  1001.        IF cOAG IN GrammarClass THEN
  1002.           i := AttrIndex;
  1003.           Class := Node;
  1004.           GenDemandProc2 (Class);
  1005.           ForallClasses (Class^.Class.Extensions, GenDemandProc2);
  1006.           Class := Node;
  1007.        END;
  1008.        WriteS (f, "   ELSE"); WriteNl (f);
  1009.        WriteS (f, "   END;"); WriteNl (f);
  1010.        WriteS (f, "  END;"); WriteNl (f);
  1011.        WriteS (f, " END y"); WI (Class^.Class.Name); WriteS (f, "y"); WI (Name); WriteS (f, ";"); WriteNl (f);
  1012.        WriteNl (f);
  1013.        k := 0;
  1014.     END;
  1015. ;
  1016.       RETURN;
  1017.      END;
  1018.  
  1019.   END;
  1020.  END GenDemandProc;
  1021.  
  1022. PROCEDURE GenDemandProc2 (t: Tree.tTree);
  1023.  VAR yyTempo: RECORD CASE : INTEGER OF
  1024.  END; END;
  1025.  BEGIN
  1026.   IF t = Tree.NoTree THEN RETURN; END;
  1027.   IF (t^.Kind = Tree.Class) THEN
  1028. (* line 651 "" *)
  1029.      WITH t^.Class DO
  1030. (* line 651 "" *)
  1031.       
  1032.     WriteS (f, "| "); WI (iMain); WriteS (f, "."); WI (Name); WriteS (f, ":"); WriteNl (f);
  1033.     WITH Instance^ [i] DO
  1034.        Class := t;
  1035.        GenDemandEval (t);
  1036.        IF Funct IN Properties THEN
  1037.           GenDemandProc2 (Action);
  1038.        ELSE
  1039.           GenEvaluator (Action); WriteNl (f);
  1040.        END;
  1041.     END;
  1042. ;
  1043.       RETURN;
  1044.      END;
  1045.  
  1046.   END;
  1047.   IF (t^.Kind = Tree.Assign) THEN
  1048. (* line 663 "" *)
  1049.      WITH t^.Assign DO
  1050. (* line 663 "" *)
  1051.       
  1052.     WriteS (f, "RETURN "); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  1053. ;
  1054.       RETURN;
  1055.      END;
  1056.  
  1057.   END;
  1058.   IF (t^.Kind = Tree.Copy) THEN
  1059. (* line 666 "" *)
  1060.      WITH t^.Copy DO
  1061. (* line 666 "" *)
  1062.       
  1063.     WriteS (f, "RETURN "); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  1064. ;
  1065.       RETURN;
  1066.      END;
  1067.  
  1068.   END;
  1069.   IF (t^.Kind = Tree.TargetCode) THEN
  1070. (* line 669 "" *)
  1071.      WITH t^.TargetCode DO
  1072. (* line 669 "" *)
  1073.       
  1074.     WriteS (f, "NoBlockStatementForDemandFunctionAttributes;"); WriteNl (f);
  1075. ;
  1076.       RETURN;
  1077.      END;
  1078.  
  1079.   END;
  1080.  END GenDemandProc2;
  1081.  
  1082. PROCEDURE GenDemandEval (t: Tree.tTree);
  1083.  VAR yyTempo: RECORD CASE : INTEGER OF
  1084.  END; END;
  1085.  BEGIN
  1086.   IF t = Tree.NoTree THEN RETURN; END;
  1087.   IF (t^.Kind = Tree.Class) THEN
  1088. (* line 676 "" *)
  1089.      WITH t^.Class DO
  1090. (* line 676 "" *)
  1091.       
  1092.     FOR j := 1 TO InstCount DO
  1093.        WITH Instance^ [j] DO
  1094.           IF IsRelated (i, j, DP) AND 
  1095.          (Demand IN Properties) AND NOT (Funct IN Properties) THEN
  1096.          IF Left IN Properties THEN
  1097.             AttrClass := GetClass (t, Attribute^.Child.Name);
  1098.             WriteS (f, "    y"); WI (AttrClass^.Class.Name); WriteS (f, "y"); WI (Attribute^.Child.Name);
  1099.             WriteS (f, " (yyt, "); GenAttribute (j, FALSE); WriteS (f, ");"); WriteNl (f);
  1100.          ELSE
  1101.             AttrClass := GetClass (Selector^.Child.Class, Attribute^.Child.Name);
  1102.             WriteS (f, "    y"); WI (AttrClass^.Class.Name); WriteS (f, "y"); WI (Attribute^.Child.Name);
  1103.             WriteS (f, " (yyt^."); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  1104.             WriteS (f, ", "); GenAttribute (j, FALSE); WriteS (f, ");"); WriteNl (f);
  1105.          END;
  1106.           END;
  1107.        END;
  1108.     END;
  1109. ;
  1110.       RETURN;
  1111.      END;
  1112.  
  1113.   END;
  1114.  END GenDemandEval;
  1115.  
  1116. PROCEDURE BeginEvalMod2;
  1117.  BEGIN
  1118. (* line 180 "" *)
  1119.  k := 0; 
  1120.  END BeginEvalMod2;
  1121.  
  1122. PROCEDURE CloseEvalMod2;
  1123.  BEGIN
  1124.  END CloseEvalMod2;
  1125.  
  1126. PROCEDURE yyExit;
  1127.  BEGIN
  1128.   IO.CloseIO; System.Exit (1);
  1129.  END yyExit;
  1130.  
  1131. BEGIN
  1132.  yyf    := IO.StdOutput;
  1133.  Exit    := yyExit;
  1134.  BeginEvalMod2;
  1135. END EvalMod2.
  1136.